package org.dromara.datacheck.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import jakarta.annotation.Resource;
import lombok.RequiredArgsConstructor;
import org.dromara.common.mybatis.core.page.TableDataInfo;
import org.dromara.datacheck.domain.bo.JstAndJDTableDataEntryBo;
import org.dromara.datacheck.domain.jd.*;
import org.dromara.datacheck.domain.jst.*;
import org.dromara.datacheck.domain.vo.jd.*;
import org.dromara.datacheck.domain.vo.jst.*;
import org.dromara.datacheck.mapper.jd.*;
import org.dromara.datacheck.mapper.jst.*;
import org.dromara.datacheck.service.IDomesticBusinessCollectService;
import org.dromara.datacheck.util.MyUtil;
import org.springframework.stereotype.Service;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 国内业务汇总统计Service业务层处理
 *
 * @author 刘武贵
 * @date 2024-11-12
 */
@RequiredArgsConstructor
@Service
public class DomesticBusinessCollectServiceImpl implements IDomesticBusinessCollectService {

    /**
     * 金蝶-直接调拨单Mapper接口
     */
    @Resource
    private JdDirectTransferOrderMapper jdDirectTransferOrderMapper;

    /**
     * 金蝶-其他入库单Mapper接口
     */
    @Resource
    private JdOtherEnterWarehouseOrderMapper jdOtherEnterWarehouseOrderMapper;

    /**
     * 金蝶-其他出库单Mapper接口
     */
    @Resource
    private JdOtherOutWarehouseOrderMapper jdOtherOutWarehouseOrderMapper;

    /**
     * 金蝶-采购入库单Mapper接口
     */
    @Resource
    private JdPurchaseEnterWarehouseOrderMapper jdPurchaseEnterWarehouseOrderMapper;

    /**
     * 金蝶-销售出库单Mapper接口
     */
    @Resource
    private JdSaleOutWarehouseOrderMapper jdSaleOutWarehouseOrderMapper;

    /**
     * 金蝶-销售退货单Mapper接口
     */
    @Resource
    private JdSaleReturnOrderMapper jdSaleReturnOrderMapper;

    /**
     * 聚水潭-售后单Mapper接口
     */
    @Resource
    private JstAfterSaleOrderMapper jstAfterSaleOrderMapper;

    /**
     * 聚水潭-调拨入单Mapper接口
     */
    @Resource
    private JstAllotEnterOrderMapper jstAllotEnterOrderMapper;

    /**
     * 聚水潭-其他出入库单Mapper接口
     */
    @Resource
    private JstOtherOutEnterWarehouseOrderMapper jstOtherOutEnterWarehouseOrderMapper;

    /**
     * 聚水潭-采购入库单Mapper接口
     */
    @Resource
    private JstPurchaseEnterWarehouseOrderMapper jstPurchaseEnterWarehouseOrderMapper;

    /**
     * 聚水潭-销售出库单Mapper接口
     */
    @Resource
    private JstSaleOutWarehouseOrderMapper jstSaleOutWarehouseOrderMapper;


    /**
     * 查询国内业务汇总统计（聚水潭和金蝶）
     *
     * @return 国内业务汇总的表格数据
     */
    @Override
    public TableDataInfo<JstAndJDTableDataEntryBo> jstAndJdSum(String monthString) {
        // 返回给前端的总的数据
        TableDataInfo<JstAndJDTableDataEntryBo> result = new TableDataInfo<>();
        // 国内业务总的数据
        List<List<Map<String, List<Map<String, List<Map<String, Integer>>>>>>> domesticBusinessCollectList = new ArrayList<>();
        // 1、根据传进的日期字符串，比如传10，那就构建第一个日期和最后一个日期作为查询业务数据的查询条件
//        String monthString = "10";
        // key 第一个时间 value 日期
        Map<String, LocalDate> dateRange = MyUtil.buildDateRange(monthString);

        // 1-1、根据当前时间来，比如当前是2024年，传的10月，就构建11月1日到30日的日期字符串集合
        List<String> datesForMonth = MyUtil.buildDatesForMonth(monthString);

        // 2、根据传进来的日期查询业务数据
        // 2-1、采购流程（含委外）-东莞仓，国内在途仓
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> purchaseProcess = this.getPurchaseProcess(dateRange, datesForMonth);
        domesticBusinessCollectList.add(purchaseProcess);

        // 2-2、2C销售
        // 销售发货
        // 销售退货（售后单）
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> twoCSales = this.getTwoCSales(dateRange, datesForMonth);
        domesticBusinessCollectList.add(twoCSales);

        // 2-3、寄售
        // 寄售调拨（猫超，进口猫超，京东自营）
        // 寄售换货-售后单(猫超售后店铺，进口猫超售后店铺)
        // 寄售换货-发货(猫超售后店铺，进口猫超售后店铺)
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> consignmentSales = this.getConsignmentSales(dateRange, datesForMonth);
        domesticBusinessCollectList.add(consignmentSales);

        // 2-4、分销（山姆）销售
        // 销售
        // 换货
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> distributionSalesBySam = this.getDistributionSalesBySam(dateRange, datesForMonth);
        domesticBusinessCollectList.add(distributionSalesBySam);

        // 2-5、部门领料
        // 网红达人店
        // 展销店铺店发货
        // 办公店铺
        // 研发店铺
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> departmentGetMaterials = this.getDepartmentGetMaterials(dateRange, datesForMonth);
        domesticBusinessCollectList.add(departmentGetMaterials);

        // 2-6、其他出库
        // 报废，盘亏
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> otherOutbound = this.getOtherOutbound(dateRange, datesForMonth);
        domesticBusinessCollectList.add(otherOutbound);

        // 2-7、其他入库
        // 供应商赔付，盘盈，领用退回
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> otherWarehousing = this.getOtherWarehousing(dateRange, datesForMonth);
        domesticBusinessCollectList.add(otherWarehousing);

        // 2-8、调拨
        // 仓库间调拨
        // 销退仓,次品仓调拨委外加工仓
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> allot = this.getAllot(dateRange, datesForMonth);
        domesticBusinessCollectList.add(allot);

        // 2-9、海外出口
        // 海外出口（东莞仓)
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> overseasExport = this.getOverseasExport(dateRange, datesForMonth);
        domesticBusinessCollectList.add(overseasExport);

        // 3、拼装数据
        result = this.concatenatedData(domesticBusinessCollectList, datesForMonth);

        return result;
    }


    /**
     * 获取采购流程（含委外）业务场景数据
     * 东莞仓，国内在途仓
     *
     * @param dateRange     一个包含开始日期和结束日期的映射，用于指定查询的日期范围
     *                      键为"start"表示开始日期，键为"end"表示结束日期
     * @param datesForMonth 当前月份的字符串集合，里面的值类似10月01日、10月02日、10月03日……
     * @return List<Map < 场景分类, List < Map < 系统平台 （ 聚水潭或金蝶 ）, List < Map < 日期 ， 数量>>>>>>的数据
     */
    private List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> getPurchaseProcess(Map<String, LocalDate> dateRange, List<String> datesForMonth) {

        // 第一个场景：采购流程（含委外）-东莞仓，国内在途仓
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstPurchaseEnterWarehouseOrder> lqw1 = Wrappers.lambdaQuery();
        lqw1.in(JstPurchaseEnterWarehouseOrder::getOperatorWarehouseOwner, Arrays.asList("深圳/东莞仓", "国内工厂在途仓"));
        lqw1.between(JstPurchaseEnterWarehouseOrder::getEnterWarehouseDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw1.eq(JstPurchaseEnterWarehouseOrder::getDataSign, "0");
        List<JstPurchaseEnterWarehouseOrderVo> jstPurchaseEnterWarehouseOrderList = jstPurchaseEnterWarehouseOrderMapper.selectVoList(lqw1);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdPurchaseEnterWarehouseOrder> lqw2 = Wrappers.lambdaQuery();
        lqw2.in(JdPurchaseEnterWarehouseOrder::getWarehouseName, Arrays.asList("东莞仓", "国内在途仓"));
        lqw2.between(JdPurchaseEnterWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdPurchaseEnterWarehouseOrderVo> jdPurchaseEnterWarehouseOrderList = jdPurchaseEnterWarehouseOrderMapper.selectVoList(lqw2);

        // 2、查出来的数据按照日期分组
        // 日期格式化
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");

        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap = jstPurchaseEnterWarehouseOrderList.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstPurchaseEnterWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstPurchaseEnterWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap.containsKey(date)) {
                jstCountMap.put(date, 0);
            }
        }
        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst = new ArrayList<>(jstCountMap.keySet());
        keysByJst.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst = new LinkedHashMap<>();
        for (String key : keysByJst) {
            sortedMapByJst.put(key, jstCountMap.get(key));
        }
        jstData.add(sortedMapByJst);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap = jdPurchaseEnterWarehouseOrderList.stream()
            .filter(order -> order.getEnterWarehouseDate() != null)
            .sorted(Comparator.comparing(JdPurchaseEnterWarehouseOrderVo::getEnterWarehouseDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getEnterWarehouseDate()),
                Collectors.summingInt(JdPurchaseEnterWarehouseOrderVo::getActualQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap.containsKey(date)) {
                jdCountMap.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd = new ArrayList<>(jdCountMap.keySet());
        keysByJd.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd = new LinkedHashMap<>();
        for (String key : keysByJd) {
            sortedMapByJd.put(key, jdCountMap.get(key));
        }
        jdData.add(sortedMapByJd);

        // 3、组装业务数据
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> purchaseProcess = new ArrayList<>();
        Map<String, List<Map<String, Integer>>> thirdFloor = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor = new HashMap<>();

        // 添加业务数据
        thirdFloor.put("聚水潭", jstData);
        thirdFloor.put("金蝶", jdData);
        secondFloor.add(thirdFloor);
        firstFloor.put("采购流程（含委外）", secondFloor);
        purchaseProcess.add(firstFloor);
        return purchaseProcess;
    }

    /**
     * 获取2C销售业务场景数据
     * 销售发货
     * 销售退货（售后单）
     *
     * @param dateRange     一个包含开始日期和结束日期的映射，用于指定查询的日期范围
     *                      键为"start"表示开始日期，键为"end"表示结束日期
     * @param datesForMonth 当前月份的字符串集合，里面的值类似10月01日、10月02日、10月03日……
     * @return List<Map < 场景分类, List < Map < 系统平台 （ 聚水潭或金蝶 ）, List < Map < 日期 ， 数量>>>>>>的数据
     */
    private List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> getTwoCSales(Map<String, LocalDate> dateRange, List<String> datesForMonth) {
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> twoCSales = new ArrayList<>();
        return twoCSales;
    }

    /**
     * 获取寄售业务场景数据
     * 寄售调拨（猫超，进口猫超，京东自营）
     * 寄售换货-售后单(猫超售后店铺，进口猫超售后店铺)
     * 寄售换货-发货(猫超售后店铺，进口猫超售后店铺)
     *
     * @param dateRange     一个包含开始日期和结束日期的映射，用于指定查询的日期范围
     *                      键为"start"表示开始日期，键为"end"表示结束日期
     * @param datesForMonth 当前月份的字符串集合，里面的值类似10月01日、10月02日、10月03日……
     * @return <场景分类,List<系统平台（聚水潭或金蝶）,List<日期，数量>>> 场景分类的数据
     */
    private List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> getConsignmentSales(Map<String, LocalDate> dateRange, List<String> datesForMonth) {

        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> consignmentSales = new ArrayList<>();
        Map<String, List<Map<String, Integer>>> thirdFloor1 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor1 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor1 = new HashMap<>();
        Map<String, List<Map<String, Integer>>> thirdFloor2 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor2 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor2 = new HashMap<>();
        Map<String, List<Map<String, Integer>>> thirdFloor3 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor3 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor3 = new HashMap<>();
        // 日期格式化
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");

        // ================ 第一个场景：寄售调拨（猫超，进口猫超，京东自营） ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstSaleOutWarehouseOrder> lqw1 = Wrappers.lambdaQuery();
        lqw1.in(JstSaleOutWarehouseOrder::getShopName, Arrays.asList("京东-TYMO京东自营店", "天猫-TYMO天猫超市", "天猫-TYMO天猫进口超市", "国内零星分销"));
        lqw1.between(JstSaleOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw1.eq(JstSaleOutWarehouseOrder::getDataSign, "0");
        List<JstSaleOutWarehouseOrderVo> jstSaleOutWarehouseOrderList1 = jstSaleOutWarehouseOrderMapper.selectVoList(lqw1);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdDirectTransferOrder> lqw2 = Wrappers.lambdaQuery();
        lqw2.in(JdDirectTransferOrder::getCustomer, Arrays.asList("TYMO京东自营店", "TYMO天猫超市", "TYMO天猫进口超市", "国内货代店铺", "零星分销店铺"));
        lqw2.between(JdDirectTransferOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdDirectTransferOrderVo> jdDirectTransferOrderList = jdDirectTransferOrderMapper.selectVoList(lqw2);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap1 = jstSaleOutWarehouseOrderList1.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstSaleOutWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstSaleOutWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap1.containsKey(date)) {
                jstCountMap1.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst1 = new ArrayList<>(jstCountMap1.keySet());
        keysByJst1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst1 = new LinkedHashMap<>();
        for (String key : keysByJst1) {
            sortedMapByJst1.put(key, jstCountMap1.get(key));
        }
        jstData1.add(sortedMapByJst1);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap1 = jdDirectTransferOrderList.stream()
            .filter(order -> order.getReceiptDate() != null)
            .sorted(Comparator.comparing(JdDirectTransferOrderVo::getReceiptDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getReceiptDate()),
                Collectors.summingInt(JdDirectTransferOrderVo::getAllotQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap1.containsKey(date)) {
                jdCountMap1.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd1 = new ArrayList<>(jdCountMap1.keySet());
        keysByJd1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd1 = new LinkedHashMap<>();
        for (String key : keysByJd1) {
            sortedMapByJd1.put(key, jdCountMap1.get(key));
        }
        jdData1.add(sortedMapByJd1);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor1.put("聚水潭", jstData1);
        thirdFloor1.put("金蝶", jdData1);
        secondFloor1.add(thirdFloor1);
        firstFloor1.put("寄售调拨（猫超，进口猫超，京东自营）", secondFloor1);
        consignmentSales.add(firstFloor1);

        // ================ 第二个场景：寄售换货-售后单(猫超售后店铺，进口猫超售后店铺) ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstAfterSaleOrder> lqw3 = Wrappers.lambdaQuery();
        lqw3.in(JstAfterSaleOrder::getShopName, Arrays.asList("天猫超市-售后店铺", "天猫进口超市-售后店铺", "京东自营-售后店铺"));
        lqw3.between(JstAfterSaleOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw3.eq(JstAfterSaleOrder::getDataSign, "0");
        List<JstAfterSaleOrderVo> jstAfterSaleOrderList = jstAfterSaleOrderMapper.selectVoList(lqw3);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdSaleReturnOrder> lqw4 = Wrappers.lambdaQuery();
        lqw4.in(JdSaleReturnOrder::getSaleReturnCustomer, Arrays.asList("猫超寄售售后", "进口超市售后店铺", "京东自营-售后店铺"));
        lqw4.between(JdSaleReturnOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdSaleReturnOrderVo> jdSaleReturnOrderList = jdSaleReturnOrderMapper.selectVoList(lqw4);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap2 = jstAfterSaleOrderList.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstAfterSaleOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstAfterSaleOrderVo::getApplyNumber)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap2.containsKey(date)) {
                jstCountMap2.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData2 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst2 = new ArrayList<>(jstCountMap2.keySet());
        keysByJst2.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst2 = new LinkedHashMap<>();
        for (String key : keysByJst2) {
            sortedMapByJst2.put(key, jstCountMap2.get(key));
        }
        jstData2.add(sortedMapByJst2);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap2 = jdSaleReturnOrderList.stream()
            .filter(order -> order.getSaleReturnOrderDate() != null)
            .sorted(Comparator.comparing(JdSaleReturnOrderVo::getSaleReturnOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getSaleReturnOrderDate()),
                Collectors.summingInt(JdSaleReturnOrderVo::getActualReturnNumber)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap2.containsKey(date)) {
                jdCountMap2.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData2 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd2 = new ArrayList<>(jdCountMap2.keySet());
        keysByJd2.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd2 = new LinkedHashMap<>();
        for (String key : keysByJd2) {
            sortedMapByJd2.put(key, jdCountMap2.get(key));
        }
        jdData2.add(sortedMapByJd2);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor2.put("聚水潭", jstData2);
        thirdFloor2.put("金蝶", jdData2);
        secondFloor2.add(thirdFloor2);
        firstFloor2.put("寄售换货-售后单(猫超售后店铺，进口猫超售后店铺)", secondFloor2);
        consignmentSales.add(firstFloor2);

        // ================ 第三个场景：寄售换货-发货(猫超售后店铺，进口猫超售后店铺) ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstSaleOutWarehouseOrder> lqw5 = Wrappers.lambdaQuery();
        lqw5.in(JstSaleOutWarehouseOrder::getShopName, Arrays.asList("天猫超市-售后店铺", "天猫进口超市-售后店铺"));
        lqw5.between(JstSaleOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw5.eq(JstSaleOutWarehouseOrder::getDataSign, "0");
        List<JstSaleOutWarehouseOrderVo> jstSaleOutWarehouseOrderList2 = jstSaleOutWarehouseOrderMapper.selectVoList(lqw5);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdSaleOutWarehouseOrder> lqw6 = Wrappers.lambdaQuery();
        lqw6.in(JdSaleOutWarehouseOrder::getSaleOutWarehouseOrderCustomer, Arrays.asList("猫超寄售售后", "进口超市售后店铺"));
        lqw6.between(JdSaleOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdSaleOutWarehouseOrderVo> jdSaleOutWarehouseOrderList = jdSaleOutWarehouseOrderMapper.selectVoList(lqw6);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap3 = jstSaleOutWarehouseOrderList2.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstSaleOutWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstSaleOutWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap3.containsKey(date)) {
                jstCountMap3.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData3 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst3 = new ArrayList<>(jstCountMap3.keySet());
        keysByJst3.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst3 = new LinkedHashMap<>();
        for (String key : keysByJst3) {
            sortedMapByJst3.put(key, jstCountMap3.get(key));
        }
        jstData3.add(sortedMapByJst3);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap3 = jdSaleOutWarehouseOrderList.stream()
            .filter(order -> order.getSaleOutWarehouseOrderDate() != null)
            .sorted(Comparator.comparing(JdSaleOutWarehouseOrderVo::getSaleOutWarehouseOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getSaleOutWarehouseOrderDate()),
                Collectors.summingInt(JdSaleOutWarehouseOrderVo::getActualDeliveryNumber)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap3.containsKey(date)) {
                jdCountMap3.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData3 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd3 = new ArrayList<>(jdCountMap3.keySet());
        keysByJd3.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd3 = new LinkedHashMap<>();
        for (String key : keysByJd3) {
            sortedMapByJd3.put(key, jdCountMap3.get(key));
        }
        jdData3.add(sortedMapByJd3);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor3.put("聚水潭", jstData3);
        thirdFloor3.put("金蝶", jdData3);
        secondFloor3.add(thirdFloor3);
        firstFloor3.put("寄售换货-发货(猫超售后店铺，进口猫超售后店铺)", secondFloor3);
        consignmentSales.add(firstFloor3);
        return consignmentSales;
    }

    /**
     * 获取分销（山姆）销售业务场景数据
     * 销售
     * 换货
     *
     * @param dateRange     一个包含开始日期和结束日期的映射，用于指定查询的日期范围
     *                      键为"start"表示开始日期，键为"end"表示结束日期
     * @param datesForMonth 当前月份的字符串集合，里面的值类似10月01日、10月02日、10月03日……
     * @return List<Map < 场景分类, List < Map < 系统平台 （ 聚水潭或金蝶 ）, List < Map < 日期 ， 数量>>>>>>的数据
     */
    private List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> getDistributionSalesBySam(Map<String, LocalDate> dateRange, List<String> datesForMonth) {
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> distributionSalesBySam = new ArrayList<>();
        Map<String, List<Map<String, Integer>>> thirdFloor1 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor1 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor1 = new HashMap<>();

        // 日期格式化
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");

        // ================ 第一个场景：销售 ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstSaleOutWarehouseOrder> lqw1 = Wrappers.lambdaQuery();
        lqw1.eq(JstSaleOutWarehouseOrder::getShopName, "国内山姆");
        lqw1.between(JstSaleOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw1.eq(JstSaleOutWarehouseOrder::getDataSign, "0");
        List<JstSaleOutWarehouseOrderVo> jstSaleOutWarehouseOrderList1 = jstSaleOutWarehouseOrderMapper.selectVoList(lqw1);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdSaleOutWarehouseOrder> lqw2 = Wrappers.lambdaQuery();
        lqw2.eq(JdSaleOutWarehouseOrder::getSaleOutWarehouseOrderCustomer, "山姆会员店");
        lqw2.between(JdSaleOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdSaleOutWarehouseOrderVo> jdSaleOutWarehouseOrderList = jdSaleOutWarehouseOrderMapper.selectVoList(lqw2);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap1 = jstSaleOutWarehouseOrderList1.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstSaleOutWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstSaleOutWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap1.containsKey(date)) {
                jstCountMap1.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst1 = new ArrayList<>(jstCountMap1.keySet());
        keysByJst1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst1 = new LinkedHashMap<>();
        for (String key : keysByJst1) {
            sortedMapByJst1.put(key, jstCountMap1.get(key));
        }
        jstData1.add(sortedMapByJst1);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap1 = jdSaleOutWarehouseOrderList.stream()
            .filter(order -> order.getSaleOutWarehouseOrderDate() != null)
            .sorted(Comparator.comparing(JdSaleOutWarehouseOrderVo::getSaleOutWarehouseOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getSaleOutWarehouseOrderDate()),
                Collectors.summingInt(JdSaleOutWarehouseOrderVo::getActualDeliveryNumber)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap1.containsKey(date)) {
                jdCountMap1.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd1 = new ArrayList<>(jdCountMap1.keySet());
        keysByJd1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd1 = new LinkedHashMap<>();
        for (String key : keysByJd1) {
            sortedMapByJd1.put(key, jdCountMap1.get(key));
        }
        jdData1.add(sortedMapByJd1);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor1.put("聚水潭", jstData1);
        thirdFloor1.put("金蝶", jdData1);
        secondFloor1.add(thirdFloor1);
        firstFloor1.put("销售", secondFloor1);
        distributionSalesBySam.add(firstFloor1);
        return distributionSalesBySam;
    }

    /**
     * 获取部门领料业务场景数据
     * 网红达人店
     * 展销店铺店发货
     * 办公店铺
     * 研发店铺
     *
     * @param dateRange     一个包含开始日期和结束日期的映射，用于指定查询的日期范围
     *                      键为"start"表示开始日期，键为"end"表示结束日期
     * @param datesForMonth 当前月份的字符串集合，里面的值类似10月01日、10月02日、10月03日……
     * @return List<Map < 场景分类, List < Map < 系统平台 （ 聚水潭或金蝶 ）, List < Map < 日期 ， 数量>>>>>>的数据
     */
    private List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> getDepartmentGetMaterials(Map<String, LocalDate> dateRange, List<String> datesForMonth) {

        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> departmentGetMaterials = new ArrayList<>();
        Map<String, List<Map<String, Integer>>> thirdFloor1 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor1 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor1 = new HashMap<>();
        Map<String, List<Map<String, Integer>>> thirdFloor2 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor2 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor2 = new HashMap<>();
        Map<String, List<Map<String, Integer>>> thirdFloor3 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor3 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor3 = new HashMap<>();
        Map<String, List<Map<String, Integer>>> thirdFloor4 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor4 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor4 = new HashMap<>();
        // 日期格式化
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");

        // ================ 第一个场景：网红达人店 ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstSaleOutWarehouseOrder> lqw1 = Wrappers.lambdaQuery();
        lqw1.eq(JstSaleOutWarehouseOrder::getShopName, "网红达人店铺");
        lqw1.between(JstSaleOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw1.eq(JstSaleOutWarehouseOrder::getDataSign, "0");
        List<JstSaleOutWarehouseOrderVo> jstSaleOutWarehouseOrderList1 = jstSaleOutWarehouseOrderMapper.selectVoList(lqw1);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdOtherOutWarehouseOrder> lqw2 = Wrappers.lambdaQuery();
        lqw2.eq(JdOtherOutWarehouseOrder::getJdOtherOutWarehouseOrderCustomer, "网红达人");
        lqw2.between(JdOtherOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdOtherOutWarehouseOrderVo> jdOtherOutWarehouseOrderList1 = jdOtherOutWarehouseOrderMapper.selectVoList(lqw2);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap1 = jstSaleOutWarehouseOrderList1.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstSaleOutWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstSaleOutWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap1.containsKey(date)) {
                jstCountMap1.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst1 = new ArrayList<>(jstCountMap1.keySet());
        keysByJst1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst1 = new LinkedHashMap<>();
        for (String key : keysByJst1) {
            sortedMapByJst1.put(key, jstCountMap1.get(key));
        }
        jstData1.add(sortedMapByJst1);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap1 = jdOtherOutWarehouseOrderList1.stream()
            .filter(order -> order.getOrderDate() != null)
            .sorted(Comparator.comparing(JdOtherOutWarehouseOrderVo::getOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getOrderDate()),
                Collectors.summingInt(JdOtherOutWarehouseOrderVo::getActualDeliveryNumber)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap1.containsKey(date)) {
                jdCountMap1.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd1 = new ArrayList<>(jdCountMap1.keySet());
        keysByJd1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd1 = new LinkedHashMap<>();
        for (String key : keysByJd1) {
            sortedMapByJd1.put(key, jdCountMap1.get(key));
        }
        jdData1.add(sortedMapByJd1);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor1.put("聚水潭", jstData1);
        thirdFloor1.put("金蝶", jdData1);
        secondFloor1.add(thirdFloor1);
        firstFloor1.put("网红达人店", secondFloor1);
        departmentGetMaterials.add(firstFloor1);

        // ================ 第二个场景：展销店铺店发货 ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstSaleOutWarehouseOrder> lqw3 = Wrappers.lambdaQuery();
        lqw3.eq(JstSaleOutWarehouseOrder::getShopName, "展销样品店铺");
        lqw3.between(JstSaleOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw3.eq(JstSaleOutWarehouseOrder::getDataSign, "0");
        List<JstSaleOutWarehouseOrderVo> jstSaleOutWarehouseOrderList2 = jstSaleOutWarehouseOrderMapper.selectVoList(lqw3);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdOtherOutWarehouseOrder> lqw4 = Wrappers.lambdaQuery();
        lqw4.eq(JdOtherOutWarehouseOrder::getJdOtherOutWarehouseOrderCustomer, "展销样品店铺");
        lqw4.between(JdOtherOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdOtherOutWarehouseOrderVo> jdOtherOutWarehouseOrderList2 = jdOtherOutWarehouseOrderMapper.selectVoList(lqw4);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap2 = jstSaleOutWarehouseOrderList2.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstSaleOutWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstSaleOutWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap2.containsKey(date)) {
                jstCountMap2.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData2 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst2 = new ArrayList<>(jstCountMap2.keySet());
        keysByJst2.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst2 = new LinkedHashMap<>();
        for (String key : keysByJst2) {
            sortedMapByJst2.put(key, jstCountMap2.get(key));
        }
        jstData2.add(sortedMapByJst2);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap2 = jdOtherOutWarehouseOrderList2.stream()
            .filter(order -> order.getNewOrderDate() != null)
            .sorted(Comparator.comparing(JdOtherOutWarehouseOrderVo::getOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getOrderDate()),
                Collectors.summingInt(JdOtherOutWarehouseOrderVo::getActualDeliveryNumber)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap2.containsKey(date)) {
                jdCountMap2.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData2 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd2 = new ArrayList<>(jdCountMap2.keySet());
        keysByJd2.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd2 = new LinkedHashMap<>();
        for (String key : keysByJd2) {
            sortedMapByJd2.put(key, jdCountMap2.get(key));
        }
        jdData2.add(sortedMapByJd2);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor2.put("聚水潭", jstData2);
        thirdFloor2.put("金蝶", jdData2);
        secondFloor2.add(thirdFloor2);
        firstFloor2.put("展销店铺店发货", secondFloor2);
        departmentGetMaterials.add(firstFloor2);

        // ================ 第三个场景：办公店铺 ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstSaleOutWarehouseOrder> lqw5 = Wrappers.lambdaQuery();
        lqw5.eq(JstSaleOutWarehouseOrder::getShopName, "办公室店铺");
        lqw5.between(JstSaleOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw5.eq(JstSaleOutWarehouseOrder::getDataSign, "0");
        List<JstSaleOutWarehouseOrderVo> jstSaleOutWarehouseOrderList3 = jstSaleOutWarehouseOrderMapper.selectVoList(lqw5);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdOtherOutWarehouseOrder> lqw6 = Wrappers.lambdaQuery();
        lqw6.eq(JdOtherOutWarehouseOrder::getJdOtherOutWarehouseOrderCustomer, "办公店铺");
        lqw6.between(JdOtherOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdOtherOutWarehouseOrderVo> jdOtherOutWarehouseOrderList3 = jdOtherOutWarehouseOrderMapper.selectVoList(lqw6);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap3 = jstSaleOutWarehouseOrderList3.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstSaleOutWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstSaleOutWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap3.containsKey(date)) {
                jstCountMap3.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData3 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst3 = new ArrayList<>(jstCountMap3.keySet());
        keysByJst3.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst3 = new LinkedHashMap<>();
        for (String key : keysByJst3) {
            sortedMapByJst3.put(key, jstCountMap3.get(key));
        }
        jstData3.add(sortedMapByJst3);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap3 = jdOtherOutWarehouseOrderList3.stream()
            .filter(order -> order.getOrderDate() != null)
            .sorted(Comparator.comparing(JdOtherOutWarehouseOrderVo::getOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getOrderDate()),
                Collectors.summingInt(JdOtherOutWarehouseOrderVo::getActualDeliveryNumber)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap3.containsKey(date)) {
                jdCountMap3.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData3 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd3 = new ArrayList<>(jdCountMap3.keySet());
        keysByJd3.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd3 = new LinkedHashMap<>();
        for (String key : keysByJd3) {
            sortedMapByJd3.put(key, jdCountMap3.get(key));
        }
        jdData3.add(sortedMapByJd3);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor3.put("聚水潭", jstData3);
        thirdFloor3.put("金蝶", jdData3);
        secondFloor3.add(thirdFloor3);
        firstFloor3.put("办公店铺", secondFloor3);
        departmentGetMaterials.add(firstFloor3);

        // ================ 第四个场景：研发店铺 ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstSaleOutWarehouseOrder> lqw7 = Wrappers.lambdaQuery();
        lqw7.eq(JstSaleOutWarehouseOrder::getShopName, "研发店铺");
        lqw7.between(JstSaleOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw7.eq(JstSaleOutWarehouseOrder::getDataSign, "0");
        List<JstSaleOutWarehouseOrderVo> jstSaleOutWarehouseOrderList4 = jstSaleOutWarehouseOrderMapper.selectVoList(lqw7);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdOtherOutWarehouseOrder> lqw8 = Wrappers.lambdaQuery();
        lqw8.eq(JdOtherOutWarehouseOrder::getJdOtherOutWarehouseOrderCustomer, "研发店铺");
        lqw8.between(JdOtherOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdOtherOutWarehouseOrderVo> jdOtherOutWarehouseOrderList4 = jdOtherOutWarehouseOrderMapper.selectVoList(lqw8);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap4 = jstSaleOutWarehouseOrderList4.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstSaleOutWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstSaleOutWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap4.containsKey(date)) {
                jstCountMap4.put(date, 0);
            }
        }
        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData4 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst4 = new ArrayList<>(jstCountMap3.keySet());
        keysByJst3.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst4 = new LinkedHashMap<>();
        for (String key : keysByJst4) {
            sortedMapByJst4.put(key, jstCountMap4.get(key));
        }
        jstData4.add(sortedMapByJst4);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap4 = jdOtherOutWarehouseOrderList4.stream()
            .filter(order -> order.getOrderDate() != null)
            .sorted(Comparator.comparing(JdOtherOutWarehouseOrderVo::getOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getOrderDate()),
                Collectors.summingInt(JdOtherOutWarehouseOrderVo::getActualDeliveryNumber)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap4.containsKey(date)) {
                jdCountMap4.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData4 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd4 = new ArrayList<>(jdCountMap4.keySet());
        keysByJd3.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd4 = new LinkedHashMap<>();
        for (String key : keysByJd4) {
            sortedMapByJd4.put(key, jdCountMap4.get(key));
        }
        jdData4.add(sortedMapByJd4);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor4.put("聚水潭", jstData4);
        thirdFloor4.put("金蝶", jdData4);
        secondFloor4.add(thirdFloor4);
        firstFloor4.put("研发店铺", secondFloor4);
        departmentGetMaterials.add(firstFloor4);
        return departmentGetMaterials;
    }

    /**
     * 获取其他出库业务场景数据
     * 报废，盘亏
     *
     * @param dateRange     一个包含开始日期和结束日期的映射，用于指定查询的日期范围
     *                      键为"start"表示开始日期，键为"end"表示结束日期
     * @param datesForMonth 当前月份的字符串集合，里面的值类似10月01日、10月02日、10月03日……
     * @return List<Map < 场景分类, List < Map < 系统平台 （ 聚水潭或金蝶 ）, List < Map < 日期 ， 数量>>>>>>的数据
     */
    private List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> getOtherOutbound(Map<String, LocalDate> dateRange, List<String> datesForMonth) {
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> otherOutbound = new ArrayList<>();
        Map<String, List<Map<String, Integer>>> thirdFloor1 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor1 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor1 = new HashMap<>();

        // 日期格式化
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");

        // ================ 第一个场景：报废，盘亏 ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstOtherOutEnterWarehouseOrder> lqw1 = Wrappers.lambdaQuery();
        lqw1.in(JstOtherOutEnterWarehouseOrder::getOutWarehouseType, Arrays.asList("报废", "盘亏"));
        lqw1.between(JstOtherOutEnterWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw1.eq(JstOtherOutEnterWarehouseOrder::getDataSign, "0");
        List<JstOtherOutEnterWarehouseOrderVo> jstOtherOutEnterWarehouseOrderList1 = jstOtherOutEnterWarehouseOrderMapper.selectVoList(lqw1);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdOtherOutWarehouseOrder> lqw2 = Wrappers.lambdaQuery();
        lqw2.like(JdOtherOutWarehouseOrder::getJdOtherOutWarehouseOrderNumber, "%QT");
        lqw2.between(JdOtherOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdOtherOutWarehouseOrderVo> jdOtherOutWarehouseOrderList1 = jdOtherOutWarehouseOrderMapper.selectVoList(lqw2);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap1 = jstOtherOutEnterWarehouseOrderList1.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstOtherOutEnterWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstOtherOutEnterWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap1.containsKey(date)) {
                jstCountMap1.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst1 = new ArrayList<>(jstCountMap1.keySet());
        keysByJst1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst1 = new LinkedHashMap<>();
        for (String key : keysByJst1) {
            sortedMapByJst1.put(key, jstCountMap1.get(key));
        }
        jstData1.add(sortedMapByJst1);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap1 = jdOtherOutWarehouseOrderList1.stream()
            .filter(order -> order.getOrderDate() != null)
            .sorted(Comparator.comparing(JdOtherOutWarehouseOrderVo::getOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getOrderDate()),
                Collectors.summingInt(JdOtherOutWarehouseOrderVo::getActualDeliveryNumber)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap1.containsKey(date)) {
                jdCountMap1.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd1 = new ArrayList<>(jdCountMap1.keySet());
        keysByJd1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd1 = new LinkedHashMap<>();
        for (String key : keysByJd1) {
            sortedMapByJd1.put(key, jdCountMap1.get(key));
        }
        jdData1.add(sortedMapByJd1);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor1.put("聚水潭", jstData1);
        thirdFloor1.put("金蝶", jdData1);
        secondFloor1.add(thirdFloor1);
        firstFloor1.put("报废，盘亏", secondFloor1);
        otherOutbound.add(firstFloor1);
        return otherOutbound;
    }

    /**
     * 获取其他入库业务场景数据
     * 供应商赔付，盘盈，领用退回
     *
     * @param dateRange     一个包含开始日期和结束日期的映射，用于指定查询的日期范围
     *                      键为"start"表示开始日期，键为"end"表示结束日期
     * @param datesForMonth 当前月份的字符串集合，里面的值类似10月01日、10月02日、10月03日……
     * @return List<Map < 场景分类, List < Map < 系统平台 （ 聚水潭或金蝶 ）, List < Map < 日期 ， 数量>>>>>>的数据
     */
    private List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> getOtherWarehousing(Map<String, LocalDate> dateRange, List<String> datesForMonth) {
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> otherWarehousing = new ArrayList<>();
        Map<String, List<Map<String, Integer>>> thirdFloor1 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor1 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor1 = new HashMap<>();

        // 日期格式化
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");

        // ================ 第一个场景：供应商赔付，盘盈，领用退回 ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstOtherOutEnterWarehouseOrder> lqw1 = Wrappers.lambdaQuery();
        lqw1.in(JstOtherOutEnterWarehouseOrder::getOutWarehouseType, Arrays.asList("供应商赔付", "盘盈", "领用退回"));
        lqw1.between(JstOtherOutEnterWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw1.eq(JstOtherOutEnterWarehouseOrder::getDataSign, "0");
        List<JstOtherOutEnterWarehouseOrderVo> jstOtherOutEnterWarehouseOrderList1 = jstOtherOutEnterWarehouseOrderMapper.selectVoList(lqw1);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdOtherEnterWarehouseOrder> lqw2 = Wrappers.lambdaQuery();
        lqw2.like(JdOtherEnterWarehouseOrder::getOtherEnterWarehouseOrderNumber, "%QT");
        lqw2.between(JdOtherEnterWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdOtherEnterWarehouseOrderVo> jdOtherEnterWarehouseOrderList1 = jdOtherEnterWarehouseOrderMapper.selectVoList(lqw2);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap1 = jstOtherOutEnterWarehouseOrderList1.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstOtherOutEnterWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstOtherOutEnterWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap1.containsKey(date)) {
                jstCountMap1.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst1 = new ArrayList<>(jstCountMap1.keySet());
        keysByJst1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst1 = new LinkedHashMap<>();
        for (String key : keysByJst1) {
            sortedMapByJst1.put(key, jstCountMap1.get(key));
        }
        jstData1.add(sortedMapByJst1);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap1 = jdOtherEnterWarehouseOrderList1.stream()
            .filter(order -> order.getOtherEnterWarehouseOrderDate() != null)
            .sorted(Comparator.comparing(JdOtherEnterWarehouseOrderVo::getOtherEnterWarehouseOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getOtherEnterWarehouseOrderDate()),
                Collectors.summingInt(JdOtherEnterWarehouseOrderVo::getActualQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap1.containsKey(date)) {
                jdCountMap1.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd1 = new ArrayList<>(jdCountMap1.keySet());
        keysByJd1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd1 = new LinkedHashMap<>();
        for (String key : keysByJd1) {
            sortedMapByJd1.put(key, jdCountMap1.get(key));
        }
        jdData1.add(sortedMapByJd1);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor1.put("聚水潭", jstData1);
        thirdFloor1.put("金蝶", jdData1);
        secondFloor1.add(thirdFloor1);
        firstFloor1.put("供应商赔付，盘盈，领用退回", secondFloor1);
        otherWarehousing.add(firstFloor1);
        return otherWarehousing;
    }

    /**
     * 获取调拨业务场景数据
     * 仓库间调拨
     * 销退仓,次品仓调拨委外加工仓
     *
     * @param dateRange     一个包含开始日期和结束日期的映射，用于指定查询的日期范围
     *                      键为"start"表示开始日期，键为"end"表示结束日期
     * @param datesForMonth 当前月份的字符串集合，里面的值类似10月01日、10月02日、10月03日……
     * @return List<Map < 场景分类, List < Map < 系统平台 （ 聚水潭或金蝶 ）, List < Map < 日期 ， 数量>>>>>>的数据
     */
    private List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> getAllot(Map<String, LocalDate> dateRange, List<String> datesForMonth) {
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> allot = new ArrayList<>();
        Map<String, List<Map<String, Integer>>> thirdFloor1 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor1 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor1 = new HashMap<>();
        Map<String, List<Map<String, Integer>>> thirdFloor2 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor2 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor2 = new HashMap<>();

        // 日期格式化
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");

        // ================ 第一个场景：仓库间调拨 ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstAllotEnterOrder> lqw1 = Wrappers.lambdaQuery();
        lqw1.between(JstAllotEnterOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw1.eq(JstAllotEnterOrder::getDataSign, "0");
        List<JstAllotEnterOrderVo> jstAllotEnterOrderList = jstAllotEnterOrderMapper.selectVoList(lqw1);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdDirectTransferOrder> lqw2 = Wrappers.lambdaQuery();
        lqw2.eq(JdDirectTransferOrder::getCalloutWarehouse, "销退仓");
        lqw2.eq(JdDirectTransferOrder::getFoldWarehouse, "东莞仓");
        lqw2.between(JdDirectTransferOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdDirectTransferOrderVo> jdDirectTransferOrderList1 = jdDirectTransferOrderMapper.selectVoList(lqw2);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap1 = jstAllotEnterOrderList.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstAllotEnterOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstAllotEnterOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap1.containsKey(date)) {
                jstCountMap1.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst1 = new ArrayList<>(jstCountMap1.keySet());
        keysByJst1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst1 = new LinkedHashMap<>();
        for (String key : keysByJst1) {
            sortedMapByJst1.put(key, jstCountMap1.get(key));
        }
        jstData1.add(sortedMapByJst1);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap1 = jdDirectTransferOrderList1.stream()
            .filter(order -> order.getReceiptDate() != null)
            .sorted(Comparator.comparing(JdDirectTransferOrderVo::getReceiptDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getReceiptDate()),
                Collectors.summingInt(JdDirectTransferOrderVo::getAllotQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap1.containsKey(date)) {
                jdCountMap1.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd1 = new ArrayList<>(jdCountMap1.keySet());
        keysByJd1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd1 = new LinkedHashMap<>();
        for (String key : keysByJd1) {
            sortedMapByJd1.put(key, jdCountMap1.get(key));
        }
        jdData1.add(sortedMapByJd1);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor1.put("聚水潭", jstData1);
        thirdFloor1.put("金蝶", jdData1);
        secondFloor1.add(thirdFloor1);
        firstFloor1.put("仓库间调拨", secondFloor1);
        allot.add(firstFloor1);

        // ================ 第二个场景：销退仓,次品仓调拨委外加工仓 ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstOtherOutEnterWarehouseOrder> lqw3 = Wrappers.lambdaQuery();
        // 出库类型，查询出库类型字段形如“仓库编码+仓库”的单子，其中仓库编码以“CK”开头
        lqw3.like(JstOtherOutEnterWarehouseOrder::getOutWarehouseType, "%CK%");
        lqw3.between(JstOtherOutEnterWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw3.eq(JstOtherOutEnterWarehouseOrder::getDataSign, "0");
        List<JstOtherOutEnterWarehouseOrderVo> jstOtherOutEnterWarehouseOrderList = jstOtherOutEnterWarehouseOrderMapper.selectVoList(lqw3);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdDirectTransferOrder> lqw4 = Wrappers.lambdaQuery();
        lqw4.like(JdDirectTransferOrder::getReceiptNumber, "%QT%");
        lqw4.between(JdDirectTransferOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdDirectTransferOrderVo> jdDirectTransferOrderList2 = jdDirectTransferOrderMapper.selectVoList(lqw4);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap2 = jstOtherOutEnterWarehouseOrderList.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstOtherOutEnterWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstOtherOutEnterWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap2.containsKey(date)) {
                jstCountMap2.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData2 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst2 = new ArrayList<>(jstCountMap2.keySet());
        keysByJst2.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst2 = new LinkedHashMap<>();
        for (String key : keysByJst2) {
            sortedMapByJst2.put(key, jstCountMap2.get(key));
        }
        jstData2.add(sortedMapByJst2);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap2 = jdDirectTransferOrderList2.stream()
            .filter(order -> order.getReceiptDate() != null)
            .sorted(Comparator.comparing(JdDirectTransferOrderVo::getReceiptDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getReceiptDate()),
                Collectors.summingInt(JdDirectTransferOrderVo::getAllotQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap2.containsKey(date)) {
                jdCountMap2.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData2 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd2 = new ArrayList<>(jdCountMap2.keySet());
        keysByJd2.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd2 = new LinkedHashMap<>();
        for (String key : keysByJd2) {
            sortedMapByJd2.put(key, jdCountMap2.get(key));
        }
        jdData2.add(sortedMapByJd2);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor2.put("聚水潭", jstData2);
        thirdFloor2.put("金蝶", jdData2);
        secondFloor2.add(thirdFloor2);
        firstFloor2.put("销退仓,次品仓调拨委外加工仓", secondFloor2);
        allot.add(firstFloor2);
        return allot;
    }

    /**
     * 获取海外出口业务场景数据
     * 海外出口（东莞仓)
     *
     * @param dateRange     一个包含开始日期和结束日期的映射，用于指定查询的日期范围
     *                      键为"start"表示开始日期，键为"end"表示结束日期
     * @param datesForMonth 当前月份的字符串集合，里面的值类似10月01日、10月02日、10月03日……
     * @return List<Map < 场景分类, List < Map < 系统平台 （ 聚水潭或金蝶 ）, List < Map < 日期 ， 数量>>>>>>的数据
     */
    private List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> getOverseasExport(Map<String, LocalDate> dateRange, List<String> datesForMonth) {
        // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
        List<Map<String, List<Map<String, List<Map<String, Integer>>>>>> overseasExport = new ArrayList<>();
        Map<String, List<Map<String, Integer>>> thirdFloor1 = new HashMap<>();
        List<Map<String, List<Map<String, Integer>>>> secondFloor1 = new ArrayList<>();
        Map<String, List<Map<String, List<Map<String, Integer>>>>> firstFloor1 = new HashMap<>();

        // 日期格式化
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd");
        // ================ 第一个场景：海外出口（东莞仓) ================
        // 1、查询两个平台数据
        // 1-1、查询聚水潭的数据
        LambdaQueryWrapper<JstSaleOutWarehouseOrder> lqw1 = Wrappers.lambdaQuery();
        lqw1.in(JstSaleOutWarehouseOrder::getShopName, Arrays.asList("海外备货店铺", "国内货代仓店铺（分销指定）"));
        lqw1.between(JstSaleOutWarehouseOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        lqw1.eq(JstSaleOutWarehouseOrder::getDataSign, "0");
        List<JstSaleOutWarehouseOrderVo> jstSaleOutWarehouseOrderList1 = jstSaleOutWarehouseOrderMapper.selectVoList(lqw1);

        // 1-2、查询金蝶的数据
        LambdaQueryWrapper<JdDirectTransferOrder> lqw2 = Wrappers.lambdaQuery();
        lqw2.in(JdDirectTransferOrder::getCustomer, Arrays.asList("海外备货店铺", "国内货代店铺"));
        lqw2.between(JdDirectTransferOrder::getNewOrderDate, dateRange.get("startDate"), dateRange.get("endDate"));
        List<JdDirectTransferOrderVo> jdDirectTransferOrderList = jdDirectTransferOrderMapper.selectVoList(lqw2);

        // 2、查出来的数据按照日期分组
        // 2-1、按照日期分组的聚水潭数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jstCountMap1 = jstSaleOutWarehouseOrderList1.stream()
            .filter(order -> order.getNewOrderDate() != null)
            // 处理聚水潭和金蝶的数据里面的日期
            .sorted(Comparator.comparing(JstSaleOutWarehouseOrderVo::getNewOrderDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringNoPadZeroByMonth(dateFormat.format(order.getNewOrderDate())),
                Collectors.summingInt(JstSaleOutWarehouseOrderVo::getQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jstCountMap1.containsKey(date)) {
                jstCountMap1.put(date, 0);
            }
        }

        // 对 jstCountMap 按键进行升序排序
        List<Map<String, Integer>> jstData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJst1 = new ArrayList<>(jstCountMap1.keySet());
        keysByJst1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJst1 = new LinkedHashMap<>();
        for (String key : keysByJst1) {
            sortedMapByJst1.put(key, jstCountMap1.get(key));
        }
        jstData1.add(sortedMapByJst1);

        // 2-1、按照日期分组的金蝶数据，按照构建的整个月的日期数去构建并且排序
        // key 为日期，value 为数量
        Map<String, Integer> jdCountMap1 = jdDirectTransferOrderList.stream()
            .filter(order -> order.getReceiptDate() != null)
            .sorted(Comparator.comparing(JdDirectTransferOrderVo::getReceiptDate))
            .collect(Collectors.groupingBy(
                order -> MyUtil.formatDateStringPadZeroByMonth(order.getReceiptDate()),
                Collectors.summingInt(JdDirectTransferOrderVo::getAllotQuantity)
            ));
        for (String date : datesForMonth) {
            if (!jdCountMap1.containsKey(date)) {
                jdCountMap1.put(date, 0);
            }
        }

        // 对 jdCountMap 按键进行升序排序
        List<Map<String, Integer>> jdData1 = new ArrayList<>();
        // 将排序后的条目放入新的有序 Map 中
        // 获取所有的键并排序
        List<String> keysByJd1 = new ArrayList<>(jdCountMap1.keySet());
        keysByJd1.sort((k1, k2) -> {
            try {
                SimpleDateFormat format = new SimpleDateFormat("MM月dd日");
                Date date1 = format.parse(k1);
                Date date2 = format.parse(k2);
                // 升序排序
                return date1.compareTo(date2);
            } catch (ParseException e) {
                throw new RuntimeException("日期格式化错误", e);
            }
        });

        // 重新构建排序后的 Map
        Map<String, Integer> sortedMapByJd1 = new LinkedHashMap<>();
        for (String key : keysByJd1) {
            sortedMapByJd1.put(key, jdCountMap1.get(key));
        }
        jdData1.add(sortedMapByJd1);

        // 3、组装业务数据
        // 添加业务数据
        thirdFloor1.put("聚水潭", jstData1);
        thirdFloor1.put("金蝶", jdData1);
        secondFloor1.add(thirdFloor1);
        firstFloor1.put("海外出口（东莞仓)", secondFloor1);
        overseasExport.add(firstFloor1);
        return overseasExport;
    }

    /**
     * 拼接国内业务数据
     *
     * @param domesticBusinessCollectList 国内业务数据
     * @return 国内业务汇总的表格数据
     */
    private TableDataInfo<JstAndJDTableDataEntryBo> concatenatedData(List<List<Map<String, List<Map<String, List<Map<String, Integer>>>>>>> domesticBusinessCollectList,
                                                                     List<String> datesForMonth) {
        List<JstAndJDTableDataEntryBo> jstAndJDTableDataEntryList = new ArrayList<>();
        JstAndJDTableDataEntryBo jstAndJDTableDataEntry = new JstAndJDTableDataEntryBo();
        List<Map<String, Object>> resultList = new ArrayList<>();
        // 1、初始化多个 Map 来存储数据，这里是行数据
        // 行示例：采购流程（含委外）	东莞仓，国内在途仓	采购入库单	采购入库单	无差异
        // 01、采购流程（含委外）-东莞仓，国内在途仓
        // ①东莞仓，国内在途仓
        Map<String, Object> purchaseProcessJd = new LinkedHashMap<>();
        Map<String, Object> purchaseProcessJst = new LinkedHashMap<>();

        // 02、2C销售
        // ①销售发货
        Map<String, Object> twoCSalesJd1 = new LinkedHashMap<>();
        Map<String, Object> twoCSalesJst1 = new LinkedHashMap<>();

        // ②销售退货（售后单）
        Map<String, Object> twoCSalesJd2 = new LinkedHashMap<>();
        Map<String, Object> twoCSalesJst2 = new LinkedHashMap<>();

        // 03、寄售
        // ①寄售调拨（猫超，进口猫超，京东自营）
        Map<String, Object> consignmentSalesJd1 = new LinkedHashMap<>();
        Map<String, Object> consignmentSalesJst1 = new LinkedHashMap<>();
        // ②寄售换货-售后单(猫超售后店铺，进口猫超售后店铺)
        Map<String, Object> consignmentSalesJd2 = new LinkedHashMap<>();
        Map<String, Object> consignmentSalesJst2 = new LinkedHashMap<>();
        // ③寄售换货-发货(猫超售后店铺，进口猫超售后店铺)
        Map<String, Object> consignmentSalesJd3 = new LinkedHashMap<>();
        Map<String, Object> consignmentSalesJst3 = new LinkedHashMap<>();
        // 04、分销（山姆）销售
        // ①销售
        Map<String, Object> distributionSalesBySamJd1 = new LinkedHashMap<>();
        Map<String, Object> distributionSalesBySamJst1 = new LinkedHashMap<>();
        // ②换货
        Map<String, Object> distributionSalesBySamJd2 = new LinkedHashMap<>();
        Map<String, Object> distributionSalesBySamJst2 = new LinkedHashMap<>();
        // 05、部门领料
        // ①网红达人店
        Map<String, Object> departmentGetMaterialsJd1 = new LinkedHashMap<>();
        Map<String, Object> departmentGetMaterialsJst1 = new LinkedHashMap<>();
        // ②展销店铺店发货
        Map<String, Object> departmentGetMaterialsJd2 = new LinkedHashMap<>();
        Map<String, Object> departmentGetMaterialsJst2 = new LinkedHashMap<>();
        // ③办公店铺
        Map<String, Object> departmentGetMaterialsJd3 = new LinkedHashMap<>();
        Map<String, Object> departmentGetMaterialsJst3 = new LinkedHashMap<>();
        // ④研发店铺
        Map<String, Object> departmentGetMaterialsJd4 = new LinkedHashMap<>();
        Map<String, Object> departmentGetMaterialsJst4 = new LinkedHashMap<>();
        // 06、其他出库
        // ①报废，盘亏
        Map<String, Object> otherOutboundJd = new LinkedHashMap<>();
        Map<String, Object> otherOutboundJst = new LinkedHashMap<>();

        // 07、其他入库
        // ①供应商赔付，盘盈，领用退回
        Map<String, Object> otherWarehousingJd = new LinkedHashMap<>();
        Map<String, Object> otherWarehousingJst = new LinkedHashMap<>();

        // 08、调拨
        // ①仓库间调拨
        Map<String, Object> allotJd1 = new LinkedHashMap<>();
        Map<String, Object> allotJst1 = new LinkedHashMap<>();
        // ②销退仓,次品仓调拨委外加工仓
        Map<String, Object> allotJd2 = new LinkedHashMap<>();
        Map<String, Object> allotJst2 = new LinkedHashMap<>();

        // 09、海外出口
        // ①海外出口（东莞仓)
        Map<String, Object> overseasExportJd = new LinkedHashMap<>();
        Map<String, Object> overseasExportJst = new LinkedHashMap<>();

        // 2、设置构建内容
        // 01、采购流程（含委外）-东莞仓，国内在途仓
        // 金蝶
        purchaseProcessJd.put("process", "采购流程（含委外）");
        purchaseProcessJd.put("sceneCategory", "东莞仓，国内在途仓");
        purchaseProcessJd.put("jstDoc", "采购入库单");
        purchaseProcessJd.put("jdDoc", "采购入库单");
        purchaseProcessJd.put("jdAndJstDocCountDiff", "无差异");
        purchaseProcessJd.put("remark", "");
        purchaseProcessJd.put("system", "金蝶");
        // 聚水潭
        purchaseProcessJst.put("process", "采购流程（含委外）");
        purchaseProcessJst.put("sceneCategory", "东莞仓，国内在途仓");
        purchaseProcessJst.put("jstDoc", "采购入库单");
        purchaseProcessJst.put("jdDoc", "采购入库单");
        purchaseProcessJst.put("jdAndJstDocCountDiff", "无差异");
        purchaseProcessJst.put("remark", "");
        purchaseProcessJst.put("system", "聚水潭");

        // 02、2C销售 twoCSales
        // ①销售发货
        // 金蝶
        twoCSalesJd1.put("process", "2C销售");
        twoCSalesJd1.put("sceneCategory", "销售发货");
        twoCSalesJd1.put("jstDoc", "销售出库单");
        twoCSalesJd1.put("jdDoc", "直接调拨单（东莞仓->在途）");
        twoCSalesJd1.put("jdAndJstDocCountDiff", "无差异");
        twoCSalesJd1.put("remark", "");
        twoCSalesJd1.put("system", "金蝶");
        // 聚水潭
        twoCSalesJst1.put("process", "2C销售");
        twoCSalesJst1.put("sceneCategory", "销售发货");
        twoCSalesJst1.put("jstDoc", "销售出库单");
        twoCSalesJst1.put("jdDoc", "直接调拨单（东莞仓->在途）");
        twoCSalesJst1.put("jdAndJstDocCountDiff", "无差异");
        twoCSalesJst1.put("remark", "");
        twoCSalesJst1.put("system", "聚水潭");
        // ②销售退货（售后单）
        // 金蝶
        twoCSalesJd2.put("process", "2C销售");
        twoCSalesJd2.put("sceneCategory", "销售退货（售后单）");
        twoCSalesJd2.put("jstDoc", "售后单");
        twoCSalesJd2.put("jdDoc", "直接调拨单（在途->销退仓）");
        twoCSalesJd2.put("jdAndJstDocCountDiff", "无差异");
        twoCSalesJd2.put("remark", "");
        twoCSalesJd2.put("system", "金蝶");
        // 聚水潭
        twoCSalesJst2.put("process", "2C销售");
        twoCSalesJst2.put("sceneCategory", "销售退货（售后单）");
        twoCSalesJst2.put("jstDoc", "售后单");
        twoCSalesJst2.put("jdDoc", "直接调拨单（在途->销退仓）");
        twoCSalesJst2.put("jdAndJstDocCountDiff", "无差异");
        twoCSalesJst2.put("remark", "");
        twoCSalesJst2.put("system", "聚水潭");

        // 03、寄售  consignmentSales
        // ①寄售调拨（猫超，进口猫超，京东自营）
        // 金蝶
        consignmentSalesJd1.put("process", "寄售");
        consignmentSalesJd1.put("sceneCategory", "寄售调拨（猫超，进口猫超，京东自营）");
        consignmentSalesJd1.put("jstDoc", "销售出库单");
        consignmentSalesJd1.put("jdDoc", "直接调拨单（东莞仓->寄售仓）");
        consignmentSalesJd1.put("jdAndJstDocCountDiff", "无差异");
        consignmentSalesJd1.put("remark", "");
        consignmentSalesJd1.put("system", "金蝶");
        // 聚水潭
        consignmentSalesJst1.put("process", "寄售");
        consignmentSalesJst1.put("sceneCategory", "寄售调拨（猫超，进口猫超，京东自营）");
        consignmentSalesJst1.put("jstDoc", "销售出库单");
        consignmentSalesJst1.put("jdDoc", "直接调拨单（东莞仓->寄售仓）");
        consignmentSalesJst1.put("jdAndJstDocCountDiff", "无差异");
        consignmentSalesJst1.put("remark", "");
        consignmentSalesJst1.put("system", "聚水潭");
        // ②寄售换货-售后单(猫超售后店铺，进口猫超售后店铺)
        // 金蝶
        consignmentSalesJd2.put("process", "寄售");
        consignmentSalesJd2.put("sceneCategory", "售换货-售后单(猫超售后店铺，进口猫超售后店铺)");
        consignmentSalesJd2.put("jstDoc", "售后单");
        consignmentSalesJd2.put("jdDoc", "销售退货单");
        consignmentSalesJd2.put("jdAndJstDocCountDiff", "无差异");
        consignmentSalesJd2.put("remark", "");
        consignmentSalesJd2.put("system", "金蝶");
        // 聚水潭
        consignmentSalesJst2.put("process", "寄售");
        consignmentSalesJst2.put("sceneCategory", "售换货-售后单(猫超售后店铺，进口猫超售后店铺)");
        consignmentSalesJst2.put("jstDoc", "售后单");
        consignmentSalesJst2.put("jdDoc", "销售退货单");
        consignmentSalesJst2.put("jdAndJstDocCountDiff", "无差异");
        consignmentSalesJst2.put("remark", "");
        consignmentSalesJst2.put("system", "聚水潭");
        // ③寄售换货-发货(猫超售后店铺，进口猫超售后店铺)
        // 金蝶
        consignmentSalesJd3.put("process", "寄售");
        consignmentSalesJd3.put("sceneCategory", "寄售换货-发货(猫超售后店铺，进口猫超售后店铺)");
        consignmentSalesJd3.put("jstDoc", "销售出库单");
        consignmentSalesJd3.put("jdDoc", "销售出库单");
        consignmentSalesJd3.put("jdAndJstDocCountDiff", "无差异");
        consignmentSalesJd3.put("remark", "");
        consignmentSalesJd3.put("system", "金蝶");
        // 聚水潭
        consignmentSalesJst3.put("process", "寄售");
        consignmentSalesJst3.put("sceneCategory", "寄售换货-发货(猫超售后店铺，进口猫超售后店铺)");
        consignmentSalesJst3.put("jstDoc", "销售出库单");
        consignmentSalesJst3.put("jdDoc", "销售出库单");
        consignmentSalesJst3.put("jdAndJstDocCountDiff", "无差异");
        consignmentSalesJst3.put("remark", "");
        consignmentSalesJst3.put("system", "聚水潭");

        // 04、分销（山姆）销售 distributionSalesBySam
        // ①销售
        // 金蝶
        distributionSalesBySamJd1.put("process", "分销（山姆）销售");
        distributionSalesBySamJd1.put("sceneCategory", "销售");
        distributionSalesBySamJd1.put("jstDoc", "销售出库单");
        distributionSalesBySamJd1.put("jdDoc", "销售出库单");
        distributionSalesBySamJd1.put("jdAndJstDocCountDiff", "无差异");
        distributionSalesBySamJd1.put("remark", "销售出库单");
        distributionSalesBySamJd1.put("system", "金蝶");
        // 聚水潭
        distributionSalesBySamJst1.put("process", "分销（山姆）销售");
        distributionSalesBySamJst1.put("sceneCategory", "销售");
        distributionSalesBySamJst1.put("jstDoc", "销售出库单");
        distributionSalesBySamJst1.put("jdDoc", "销售出库单");
        distributionSalesBySamJst1.put("jdAndJstDocCountDiff", "无差异");
        distributionSalesBySamJst1.put("remark", "");
        distributionSalesBySamJst1.put("system", "聚水潭");
        // ②换货
        // 金蝶
        distributionSalesBySamJd2.put("process", "分销（山姆）销售");
        distributionSalesBySamJd2.put("sceneCategory", "换货");
        distributionSalesBySamJd2.put("jstDoc", "销售出库单");
        distributionSalesBySamJd2.put("jdDoc", "销售出库单");
        distributionSalesBySamJd2.put("jdAndJstDocCountDiff", "无差异");
        distributionSalesBySamJd2.put("remark", "");
        distributionSalesBySamJd2.put("system", "金蝶");
        // 聚水潭
        distributionSalesBySamJst2.put("process", "分销（山姆）销售");
        distributionSalesBySamJst2.put("sceneCategory", "换货");
        distributionSalesBySamJst2.put("jstDoc", "销售出库单");
        distributionSalesBySamJst2.put("jdDoc", "销售出库单");
        distributionSalesBySamJst2.put("jdAndJstDocCountDiff", "无差异");
        distributionSalesBySamJst2.put("remark", "");
        distributionSalesBySamJst2.put("system", "聚水潭");

        // 05、部门领料 departmentGetMaterials
        // ①网红达人店
        // 金蝶
        departmentGetMaterialsJd1.put("process", "部门领料");
        departmentGetMaterialsJd1.put("sceneCategory", "网红达人店");
        departmentGetMaterialsJd1.put("jstDoc", "销售出库单");
        departmentGetMaterialsJd1.put("jdDoc", "");
        departmentGetMaterialsJd1.put("jdAndJstDocCountDiff", "无差异");
        departmentGetMaterialsJd1.put("remark", "");
        departmentGetMaterialsJd1.put("system", "金蝶");
        // 聚水潭
        departmentGetMaterialsJst1.put("process", "部门领料");
        departmentGetMaterialsJst1.put("sceneCategory", "网红达人店");
        departmentGetMaterialsJst1.put("jstDoc", "销售出库单");
        departmentGetMaterialsJst1.put("jdDoc", "");
        departmentGetMaterialsJst1.put("jdAndJstDocCountDiff", "无差异");
        departmentGetMaterialsJst1.put("remark", "");
        departmentGetMaterialsJst1.put("system", "聚水潭");
        // ②展销店铺店发货
        // 金蝶
        departmentGetMaterialsJd2.put("process", "部门领料");
        departmentGetMaterialsJd2.put("sceneCategory", "展销店铺店发货");
        departmentGetMaterialsJd2.put("jstDoc", "销售出库单");
        departmentGetMaterialsJd2.put("jdDoc", "其他出库单");
        departmentGetMaterialsJd2.put("jdAndJstDocCountDiff", "无差异");
        departmentGetMaterialsJd2.put("remark", "");
        departmentGetMaterialsJd2.put("system", "金蝶");
        // 聚水潭
        departmentGetMaterialsJst2.put("process", "部门领料");
        departmentGetMaterialsJst2.put("sceneCategory", "展销店铺店发货");
        departmentGetMaterialsJst2.put("jstDoc", "销售出库单");
        departmentGetMaterialsJst2.put("jdDoc", "其他出库单");
        departmentGetMaterialsJst2.put("jdAndJstDocCountDiff", "无差异");
        departmentGetMaterialsJst2.put("remark", "");
        departmentGetMaterialsJst2.put("system", "聚水潭");
        // ③办公店铺
        // 金蝶
        departmentGetMaterialsJd3.put("process", "部门领料");
        departmentGetMaterialsJd3.put("sceneCategory", "办公店铺");
        departmentGetMaterialsJd3.put("jstDoc", "销售出库单");
        departmentGetMaterialsJd3.put("jdDoc", "其他出库单");
        departmentGetMaterialsJd3.put("jdAndJstDocCountDiff", "无差异");
        departmentGetMaterialsJd3.put("remark", "");
        departmentGetMaterialsJd3.put("system", "金蝶");
        // 聚水潭
        departmentGetMaterialsJst3.put("process", "部门领料");
        departmentGetMaterialsJst3.put("sceneCategory", "办公店铺");
        departmentGetMaterialsJst3.put("jstDoc", "销售出库单");
        departmentGetMaterialsJst3.put("jdDoc", "其他出库单");
        departmentGetMaterialsJst3.put("jdAndJstDocCountDiff", "无差异");
        departmentGetMaterialsJst3.put("remark", "");
        departmentGetMaterialsJst3.put("system", "聚水潭");
        // ④研发店铺
        // 金蝶
        departmentGetMaterialsJd4.put("process", "部门领料");
        departmentGetMaterialsJd4.put("sceneCategory", "研发店铺");
        departmentGetMaterialsJd4.put("jstDoc", "销售出库单");
        departmentGetMaterialsJd4.put("jdDoc", "其他出库单");
        departmentGetMaterialsJd4.put("jdAndJstDocCountDiff", "无差异");
        departmentGetMaterialsJd4.put("remark", "");
        departmentGetMaterialsJd4.put("system", "金蝶");
        // 聚水潭
        departmentGetMaterialsJst4.put("process", "部门领料");
        departmentGetMaterialsJst4.put("sceneCategory", "研发店铺");
        departmentGetMaterialsJst4.put("jstDoc", "销售出库单");
        departmentGetMaterialsJst4.put("jdDoc", "其他出库单");
        departmentGetMaterialsJst4.put("jdAndJstDocCountDiff", "无差异");
        departmentGetMaterialsJst4.put("remark", "");
        departmentGetMaterialsJst4.put("system", "聚水潭");

        // 06、其他出库
        // ①报废，盘亏
        // 金蝶
        otherOutboundJd.put("process", "其他出库");
        otherOutboundJd.put("sceneCategory", "报废，盘亏");
        otherOutboundJd.put("jstDoc", "其他出库单");
        otherOutboundJd.put("jdDoc", "其他出库单");
        otherOutboundJd.put("jdAndJstDocCountDiff", "无差异");
        otherOutboundJd.put("remark", "");
        otherOutboundJd.put("system", "金蝶");
        // 聚水潭
        otherOutboundJst.put("process", "其他出库");
        otherOutboundJst.put("sceneCategory", "报废，盘亏");
        otherOutboundJst.put("jstDoc", "其他出库单");
        otherOutboundJst.put("jdDoc", "其他出库单");
        otherOutboundJst.put("jdAndJstDocCountDiff", "无差异");
        otherOutboundJst.put("remark", "");
        otherOutboundJst.put("system", "聚水潭");

        // 07、其他入库 otherWarehousing
        // ①供应商赔付，盘盈，领用退回
        // 金蝶
        otherWarehousingJd.put("process", "其他入库");
        otherWarehousingJd.put("sceneCategory", "供应商赔付，盘盈，领用退回");
        otherWarehousingJd.put("jstDoc", "其他入库单");
        otherWarehousingJd.put("jdDoc", "其他入库单");
        otherWarehousingJd.put("jdAndJstDocCountDiff", "无差异");
        otherWarehousingJd.put("remark", "");
        otherWarehousingJd.put("system", "金蝶");
        // 聚水潭
        otherWarehousingJst.put("process", "其他入库");
        otherWarehousingJst.put("sceneCategory", "供应商赔付，盘盈，领用退回");
        otherWarehousingJst.put("jstDoc", "其他入库单");
        otherWarehousingJst.put("jdDoc", "其他入库单");
        otherWarehousingJst.put("jdAndJstDocCountDiff", "无差异");
        otherWarehousingJst.put("remark", "");
        otherWarehousingJst.put("system", "聚水潭");

        // 08、调拨 allot
        // ①仓库间调拨
        // 金蝶
        allotJd1.put("process", "调拨");
        allotJd1.put("sceneCategory", "仓库间调拨");
        allotJd1.put("jstDoc", "调拨单");
        allotJd1.put("jdDoc", "直接调拨单");
        allotJd1.put("jdAndJstDocCountDiff", "无差异");
        allotJd1.put("remark", "");
        allotJd1.put("system", "金蝶");
        // 聚水潭
        allotJst1.put("process", "调拨");
        allotJst1.put("sceneCategory", "仓库间调拨");
        allotJst1.put("jstDoc", "调拨单");
        allotJst1.put("jdDoc", "直接调拨单");
        allotJst1.put("jdAndJstDocCountDiff", "无差异");
        allotJst1.put("remark", "");
        allotJst1.put("system", "聚水潭");
        // ②销退仓,次品仓调拨委外加工仓
        // 金蝶
        allotJd2.put("process", "调拨");
        allotJd2.put("sceneCategory", "销退仓,次品仓调拨委外加工仓");
        allotJd2.put("jstDoc", "其他出库单");
        allotJd2.put("jdDoc", "直接调拨单");
        allotJd2.put("jdAndJstDocCountDiff", "无差异");
        allotJd2.put("remark", "");
        allotJd2.put("system", "金蝶");
        // 聚水潭
        allotJst2.put("process", "调拨");
        allotJst2.put("sceneCategory", "销退仓,次品仓调拨委外加工仓");
        allotJst2.put("jstDoc", "其他出库单");
        allotJst2.put("jdDoc", "直接调拨单");
        allotJst2.put("jdAndJstDocCountDiff", "无差异");
        allotJst2.put("remark", "");
        allotJst2.put("system", "聚水潭");

        // 09、海外出口 overseasExport
        // ①海外出口（东莞仓)
        // 金蝶
        overseasExportJd.put("process", "海外出口");
        overseasExportJd.put("sceneCategory", "海外出口（东莞仓)");
        overseasExportJd.put("jstDoc", "销售出库单");
        overseasExportJd.put("jdDoc", "直接调拨单(东莞仓->待报关在途仓） 直接调拨单(东莞仓->待报关货代仓）");
        overseasExportJd.put("jdAndJstDocCountDiff", "无差异");
        overseasExportJd.put("remark", "");
        overseasExportJd.put("system", "金蝶");
        // 聚水潭
        overseasExportJst.put("process", "海外出口");
        overseasExportJst.put("sceneCategory", "海外出口（东莞仓)");
        overseasExportJst.put("jstDoc", "销售出库单");
        overseasExportJst.put("jdDoc", "直接调拨单(东莞仓->待报关在途仓）直接调拨单(东莞仓->待报关货代仓）");
        overseasExportJst.put("jdAndJstDocCountDiff", "无差异");
        overseasExportJst.put("remark", "");
        overseasExportJst.put("system", "聚水潭");

        // 3、构建形如<date1,日期>的key value对，这个是前端要求
        Map<String, String> dateMap = MyUtil.buildDateMap(datesForMonth);

        // 4、构建列数据
        // 数据格式形如:
        // [
        //                {
        //                    "label": "系统",
        //                    "prop": "label"
        //                },
        //                {
        //                    "label": "2024年07月31日",
        //                    "prop": "date1"
        //                },
        // ]
        List<Map<String, Object>> columnList = new ArrayList<>();

        // 添加 "系统" 列
        Map<String, Object> systemColumn = new LinkedHashMap<>();
        systemColumn.put("label", "系统");
        systemColumn.put("prop", "label");
        columnList.add(systemColumn);

        // 5、添加日期列
        for (int i = 0; i < datesForMonth.size() + 1; i++) {
            Map<String, Object> dateColumn = new LinkedHashMap<>();
            // 可以根据需要修改日期格式，根据业务需要，这里先按照date1这样处理
            dateColumn.put("label", dateMap.get("date" + i));
            dateColumn.put("prop", "date" + i);
            columnList.add(dateColumn);
        }

        // 5-1、遍历日期列表，填充业务数据
        int dateIndex = 1;
        for (String date : datesForMonth) {
            // List<Map<场景分类,List<Map<系统平台（聚水潭或金蝶）,List<Map<日期，数量>>>>>>
            // List<List<Map<String, List<Map<String, List<Map<String, Integer>>>>>>>
            // 5-2、获取具体的业务日期数据
            // 01、采购流程（含委外）-东莞仓，国内在途仓 purchaseProcess jstCountMap.getOrDefault(date, 0);
            // ①东莞仓，国内在途仓
            // 金蝶
            int jdCount1 = domesticBusinessCollectList.get(0).get(0).get("采购流程（含委外）").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount1 = domesticBusinessCollectList.get(0).get(0).get("采购流程（含委外）").get(0).get("聚水潭").get(0).get(date);
            // 02、2C销售
            // ①销售发货
            // 金蝶
//'            int jdCount2 = domesticBusinessCollectList.get(0).get(0).get("").get(0).get("金蝶").get(0).get(date);
//            // 聚水潭
//            int jstCount2 = domesticBusinessCollectList.get(0).get(0).get("").get(0).get("聚水潭").get(0).get(date);
//            // ②销售退货（售后单）
//            // 金蝶
//            int jdCount3 = domesticBusinessCollectList.get(1).get(1).get("").get(1).get("金蝶").get(0).get(date);
//            // 聚水潭
//            int jstCount3 = domesticBusinessCollectList.get(1).get(1).get("").get(1).get("聚水潭").get(0).get(date);'

            // 03、寄售
            // ①寄售调拨（猫超，进口猫超，京东自营）
            // 金蝶
            int jdCount4 = domesticBusinessCollectList.get(2).get(0).get("寄售调拨（猫超，进口猫超，京东自营）").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount4 = domesticBusinessCollectList.get(2).get(0).get("寄售调拨（猫超，进口猫超，京东自营）").get(0).get("聚水潭").get(0).get(date);
//            // ②寄售换货-售后单(猫超售后店铺，进口猫超售后店铺)
//            // 金蝶
//            int jdCount5 = domesticBusinessCollectList.get(2).get(1).get("售换货-售后单(猫超售后店铺，进口猫超售后店铺)").get(0).get("金蝶").get(0).get(date);
//            // 聚水潭
//            int jstCount5 = domesticBusinessCollectList.get(2).get(1).get("售换货-售后单(猫超售后店铺，进口猫超售后店铺)").get(0).get("聚水潭").get(0).get(date);
            // ③寄售换货-发货(猫超售后店铺，进口猫超售后店铺)
            // 金蝶
            int jdCount6 = domesticBusinessCollectList.get(2).get(2).get("寄售换货-发货(猫超售后店铺，进口猫超售后店铺)").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount6 = domesticBusinessCollectList.get(2).get(2).get("寄售换货-发货(猫超售后店铺，进口猫超售后店铺)").get(0).get("聚水潭").get(0).get(date);

            // 04、分销（山姆）销售
            // ①销售
            // 金蝶
            int jdCount7 = domesticBusinessCollectList.get(3).get(0).get("销售").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount7 = domesticBusinessCollectList.get(3).get(0).get("销售").get(0).get("聚水潭").get(0).get(date);
//            // ②换货
//            // 金蝶
//            int jdCount8 = domesticBusinessCollectList.get(2).get(1).get("").get(0).get("金蝶").get(0).get(date);
//            // 聚水潭
//            int jstCount8 = domesticBusinessCollectList.get(2).get(1).get("").get(0).get("聚水潭").get(0).get(date);

            // 05、部门领料
            // ①网红达人店
            // 金蝶
            int jdCount9 = domesticBusinessCollectList.get(4).get(0).get("网红达人店").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount9 = domesticBusinessCollectList.get(4).get(0).get("网红达人店").get(0).get("聚水潭").get(0).get(date);
            // ②展销店铺店发货
            // 金蝶
            int jdCount10 = domesticBusinessCollectList.get(4).get(1).get("展销店铺店发货").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount10 = domesticBusinessCollectList.get(4).get(1).get("展销店铺店发货").get(0).get("聚水潭").get(0).get(date);
            // ③办公店铺
            // 金蝶
            int jdCount11 = domesticBusinessCollectList.get(4).get(2).get("办公店铺").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount11 = domesticBusinessCollectList.get(4).get(2).get("办公店铺").get(0).get("聚水潭").get(0).get(date);
            // ④研发店铺
            // 金蝶
            int jdCount12 = domesticBusinessCollectList.get(4).get(3).get("研发店铺").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount12 = domesticBusinessCollectList.get(4).get(3).get("研发店铺").get(0).get("聚水潭").get(0).get(date);

            // 06、其他出库
            // ①报废，盘亏
            // 金蝶
            int jdCount13 = domesticBusinessCollectList.get(5).get(0).get("报废，盘亏").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount13 = domesticBusinessCollectList.get(5).get(0).get("报废，盘亏").get(0).get("聚水潭").get(0).get(date);

            // 07、其他入库
            // ①供应商赔付，盘盈，领用退回
            // 金蝶
            int jdCount14 = domesticBusinessCollectList.get(6).get(0).get("供应商赔付，盘盈，领用退回").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount14 = domesticBusinessCollectList.get(6).get(0).get("供应商赔付，盘盈，领用退回").get(0).get("聚水潭").get(0).get(date);

            // 08、调拨
            // ①仓库间调拨
            // 金蝶
            int jdCount15 = domesticBusinessCollectList.get(7).get(0).get("仓库间调拨").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount15 = domesticBusinessCollectList.get(7).get(0).get("仓库间调拨").get(0).get("聚水潭").get(0).get(date);
            // ②销退仓,次品仓调拨委外加工仓
            // 金蝶
            int jdCount16 = domesticBusinessCollectList.get(7).get(1).get("销退仓,次品仓调拨委外加工仓").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount16 = domesticBusinessCollectList.get(7).get(1).get("销退仓,次品仓调拨委外加工仓").get(0).get("聚水潭").get(0).get(date);

            // 09、海外出口
            // ①海外出口（东莞仓)
            // 金蝶
            int jdCount17 = domesticBusinessCollectList.get(8).get(0).get("海外出口（东莞仓)").get(0).get("金蝶").get(0).get(date);
            // 聚水潭
            int jstCount17 = domesticBusinessCollectList.get(8).get(0).get("海外出口（东莞仓)").get(0).get("聚水潭").get(0).get(date);

            // 5-3、填充具体的业务数据
            // 01、采购流程（含委外）-东莞仓，国内在途仓 purchaseProcess
            // 金蝶
            purchaseProcessJd.put("date" + dateIndex, jdCount1);
            // 聚水潭
            purchaseProcessJst.put("date" + dateIndex, jstCount1);

//            // 02、2C销售
//            // ①销售发货
//            // 金蝶
//            twoCSalesJd1.put("date" + dateIndex, jdCount2);
//            // 聚水潭
//            twoCSalesJst1.put("date" + dateIndex, jstCount2);
//            // ②销售退货（售后单）
//            // 金蝶
//            twoCSalesJd2.put("date" + dateIndex, jdCount3);
//            // 聚水潭
//            twoCSalesJst2.put("date" + dateIndex, jstCount3);

            // 03、寄售
            // ①寄售调拨（猫超，进口猫超，京东自营）
            // 金蝶
            consignmentSalesJd1.put("date" + dateIndex, jdCount4);
            // 聚水潭
            consignmentSalesJst1.put("date" + dateIndex, jstCount4);
//            // ②寄售换货-售后单(猫超售后店铺，进口猫超售后店铺)
//            // 金蝶
//            consignmentSalesJd2.put("date" + dateIndex, jdCount5);
//            // 聚水潭
//            consignmentSalesJst2.put("date" + dateIndex, jstCount5);
            // ③寄售换货-发货(猫超售后店铺，进口猫超售后店铺)
            // 金蝶
            consignmentSalesJd3.put("date" + dateIndex, jdCount6);
            // 聚水潭
            consignmentSalesJst3.put("date" + dateIndex, jstCount6);

            // 04、分销（山姆）销售
            // ①销售
            // 金蝶
            distributionSalesBySamJd1.put("date" + dateIndex, jdCount7);
            // 聚水潭
            distributionSalesBySamJst1.put("date" + dateIndex, jstCount7);
//            // ②换货
//            // 金蝶
//            distributionSalesBySamJd2.put("date" + dateIndex, jdCount8);
//            // 聚水潭
//            distributionSalesBySamJst2.put("date" + dateIndex, jstCount8);

            // 05、部门领料
            // ①网红达人店
            // 金蝶
            departmentGetMaterialsJd1.put("date" + dateIndex, jdCount9);
            // 聚水潭
            departmentGetMaterialsJst1.put("date" + dateIndex, jstCount9);
            // ②展销店铺店发货
            // 金蝶
            departmentGetMaterialsJd2.put("date" + dateIndex, jdCount10);
            // 聚水潭
            departmentGetMaterialsJst2.put("date" + dateIndex, jstCount10);
            // ③办公店铺
            // 金蝶
            departmentGetMaterialsJd3.put("date" + dateIndex, jdCount11);
            // 聚水潭
            departmentGetMaterialsJst3.put("date" + dateIndex, jstCount11);
            // ④研发店铺
            // 金蝶
            departmentGetMaterialsJd4.put("date" + dateIndex, jdCount12);
            // 聚水潭
            departmentGetMaterialsJst4.put("date" + dateIndex, jstCount12);

            // 06、其他出库
            // ①报废，盘亏
            // 金蝶
            otherOutboundJd.put("date" + dateIndex, jdCount13);
            // 聚水潭
            otherOutboundJst.put("date" + dateIndex, jstCount13);

            // 07、其他入库
            // ①供应商赔付，盘盈，领用退回
            // 金蝶
            otherWarehousingJd.put("date" + dateIndex, jdCount14);
            // 聚水潭
            otherWarehousingJst.put("date" + dateIndex, jstCount14);

            // 08、调拨
            // ①仓库间调拨
            // 金蝶
            allotJd1.put("date" + dateIndex, jdCount15);
            // 聚水潭
            allotJst1.put("date" + dateIndex, jstCount15);
            // ②销退仓,次品仓调拨委外加工仓
            // 金蝶
            allotJd2.put("date" + dateIndex, jdCount16);
            // 聚水潭
            allotJst2.put("date" + dateIndex, jstCount16);

            // 09、海外出口
            // ①海外出口（东莞仓)
            // 金蝶
            overseasExportJd.put("date" + dateIndex, jdCount17);
            // 聚水潭
            overseasExportJst.put("date" + dateIndex, jstCount17);

            dateIndex++;
        }
        // 5、将多个 Map 添加到结果列表中
        // 01、采购流程（含委外）-purchaseProcess
        // ①东莞仓，国内在途仓
        // 金蝶
        resultList.add(purchaseProcessJd);
        // 聚水潭
        resultList.add(purchaseProcessJst);

//        // 02、2C销售 twoCSales
//        // ①销售发货
//        // 金蝶
//        resultList.add(twoCSalesJd1);
//        // 聚水潭
//        resultList.add(twoCSalesJst1);
//        // ②销售退货（售后单）
//        // 金蝶
//        resultList.add(twoCSalesJd2);
//        // 聚水潭
//        resultList.add(twoCSalesJst2);

        // 03、寄售  consignmentSales
        // ①寄售调拨（猫超，进口猫超，京东自营）
        // 金蝶
        resultList.add(consignmentSalesJd1);
        // 聚水潭
        resultList.add(consignmentSalesJst1);
//        // ②寄售换货-售后单(猫超售后店铺，进口猫超售后店铺)
//        // 金蝶
//        resultList.add(consignmentSalesJd2);
//        // 聚水潭
//        resultList.add(consignmentSalesJst2);
        // ③寄售换货-发货(猫超售后店铺，进口猫超售后店铺)
        // 金蝶
        resultList.add(consignmentSalesJd3);
        // 聚水潭
        resultList.add(consignmentSalesJst3);

        // 04、分销（山姆）销售 distributionSalesBySam
        // ①销售
        // 金蝶
        resultList.add(distributionSalesBySamJd1);
        // 聚水潭
        resultList.add(distributionSalesBySamJst1);
//        // ②换货
//        // 金蝶
//        resultList.add(distributionSalesBySamJd2);
//        // 聚水潭
//        resultList.add(distributionSalesBySamJst2);

        // 05、部门领料 departmentGetMaterials
        // ①网红达人店
        // 金蝶
        resultList.add(departmentGetMaterialsJd1);
        // 聚水潭
        resultList.add(departmentGetMaterialsJst1);
        // ②展销店铺店发货
        // 金蝶
        resultList.add(departmentGetMaterialsJd2);
        // 聚水潭
        resultList.add(departmentGetMaterialsJst2);
        // ③办公店铺
        // 金蝶
        resultList.add(departmentGetMaterialsJd3);
        // 聚水潭
        resultList.add(departmentGetMaterialsJst3);
        // ④研发店铺
        // 金蝶
        resultList.add(departmentGetMaterialsJd4);
        // 聚水潭
        resultList.add(departmentGetMaterialsJst4);

        // 06、其他出库 otherOutbound
        // ①报废，盘亏
        // 金蝶
        resultList.add(otherOutboundJd);
        // 聚水潭
        resultList.add(otherOutboundJst);

        // 07、其他入库 otherWarehousing
        // ①供应商赔付，盘盈，领用退回
        // 金蝶
        resultList.add(otherWarehousingJd);
        // 聚水潭
        resultList.add(otherWarehousingJst);

        // 08、调拨 allot
        // ①仓库间调拨
        // 金蝶
        resultList.add(allotJd1);
        // 聚水潭
        resultList.add(allotJst1);
        // ②销退仓,次品仓调拨委外加工仓
        // 金蝶
        resultList.add(allotJd2);
        // 聚水潭
        resultList.add(allotJst2);

        // 09、海外出口 overseasExport
        // ①海外出口（东莞仓)
        // 金蝶
        resultList.add(overseasExportJd);
        // 聚水潭
        resultList.add(overseasExportJst);

        // 6、设置表格数据
        jstAndJDTableDataEntry.setColumnList(columnList);
        jstAndJDTableDataEntry.setTableList(resultList);
        jstAndJDTableDataEntryList.add(jstAndJDTableDataEntry);

        // 7、构建JSON，构建返回数据
        TableDataInfo<JstAndJDTableDataEntryBo> result = new TableDataInfo<>();
        result.setRows(jstAndJDTableDataEntryList);
        result.setMsg("查询成功");

        return result;

    }

    /**
     * 根据提供的日期字符串列表构建一个映射，其中列表中的每个日期对应一个键值对。
     * 键是由'date'前缀和列表中日期的索引组成的字符串，值是格式化后的日期字符串。
     * 形如<date1,日期>的key value对
     *
     * @param formattedDateList 包含格式化后日期字符串的列表，不能为空。
     * @return 返回一个按插入顺序保存的映射，其中键是'dateN'形式的字符串（N是索引），值是对应的日期字符串。
     */
    public static Map<String, String> buildDateMap(List<String> formattedDateList) {
        // 创建一个链接哈希映射来保持元素的插入顺序
        Map<String, String> dateMap = new LinkedHashMap<>();

        // 初始化索引值
        int index = 1;
        // 遍历日期字符串列表
        for (String date : formattedDateList) {
            // 为每个日期生成键名，格式为'date1', 'date2', ...
            String key = "date" + index;
            // 将键值对添加到映射中
            dateMap.put(key, date);
            // 更新索引值
            index++;
        }

        // 返回构建好的日期映射
        return dateMap;
    }


}
